1class NotificationType(Enum):
2    EMAIL = "EMAIL"
3    SMS = "SMS"
4    PUSH = "PUSH"

1class Recipient:
2    def __init__(self, user_id: str, email: Optional[str] = None, phone_number: Optional[str] = None, push_token: Optional[str] = None):
3        self.user_id = user_id
4        self.email = email
5        self.phone_number = phone_number
6        self.push_token = push_token
7
8    def get_user_id(self) -> str:
9        return self.user_id
10
11    def get_email(self) -> Optional[str]:
12        return self.email
13
14    def get_phone_number(self) -> Optional[str]:
15        return self.phone_number
16
17    def get_push_token(self) -> Optional[str]:
18        return self.push_token

1class Notification:
2    def __init__(self, builder):
3        self.id = str(uuid.uuid4())
4        self.recipient = builder.recipient
5        self.type = builder.type
6        self.message = builder.message
7        self.subject = builder.subject
8
9    def get_id(self) -> str:
10        return self.id
11
12    def get_recipient(self) -> Recipient:
13        return self.recipient
14
15    def get_type(self) -> NotificationType:
16        return self.type
17
18    def get_message(self) -> str:
19        return self.message
20
21    def get_subject(self) -> str:
22        return self.subject
23
24    class Builder:
25        def __init__(self, recipient: Recipient, notification_type: NotificationType):
26            self.recipient = recipient
27            self.type = notification_type
28            self.message = None
29            self.subject = None
30
31        def message(self, message: str):
32            self.message = message
33            return self
34
35        def subject(self, subject: str):
36            self.subject = subject
37            return self
38
39        def build(self):
40            return Notification(self)

1class NotificationGateway(ABC):
2    @abstractmethod
3    def send(self, notification: Notification):
4        pass
5
6
7class EmailGateway(NotificationGateway):
8    def send(self, notification: Notification):
9        email = notification.get_recipient().get_email()
10        if email is None:
11            raise ValueError("Email address is required for EMAIL notification.")
12        
13        print("--- Sending EMAIL ---")
14        print(f"To: {email}")
15        print(f"Subject: {notification.get_subject()}")
16        print(f"Body: {notification.get_message()}")
17        print("---------------------\n")
18
19
20class PushGateway(NotificationGateway):
21    def send(self, notification: Notification):
22        token = notification.get_recipient().get_push_token()
23        if token is None:
24            raise ValueError("Push token is required for PUSH notification.")
25        
26        print("--- Sending PUSH Notification ---")
27        print(f"To Device Token: {token}")
28        print(f"Title: {notification.get_subject()}")
29        print(f"Body: {notification.get_message()}")
30        print("---------------------------------\n")
31
32
33class SmsGateway(NotificationGateway):
34    def send(self, notification: Notification):
35        phone = notification.get_recipient().get_phone_number()
36        if phone is None:
37            raise ValueError("Phone number is required for SMS notification.")
38        
39        print("--- Sending SMS ---")
40        print(f"To: {phone}")
41        print(f"Message: {notification.get_message()}")
42        print("-------------------\n")

1class NotificationFactory:
2    _gateway_map: Dict[NotificationType, NotificationGateway] = {}
3
4    @classmethod
5    def create_gateway(cls, notification_type: NotificationType) -> NotificationGateway:
6        if notification_type in cls._gateway_map:
7            return cls._gateway_map[notification_type]
8
9        gateway = None
10
11        if notification_type == NotificationType.EMAIL:
12            gateway = EmailGateway()
13        elif notification_type == NotificationType.SMS:
14            gateway = SmsGateway()
15        elif notification_type == NotificationType.PUSH:
16            gateway = PushGateway()
17
18        cls._gateway_map[notification_type] = gateway
19        return gateway

1class RetryableGatewayDecorator(NotificationGateway):
2    def __init__(self, wrapped_gateway: NotificationGateway, max_retries: int, retry_delay_millis: int):
3        self.wrapped_gateway = wrapped_gateway
4        self.max_retries = max_retries
5        self.retry_delay_millis = retry_delay_millis
6
7    def send(self, notification: Notification):
8        attempt = 0
9        while attempt < self.max_retries:
10            try:
11                self.wrapped_gateway.send(notification)
12                return  # Success
13            except Exception as e:
14                attempt += 1
15                print(f"Error: Attempt {attempt} failed for notification {notification.get_id()}. Retrying...")
16                if attempt >= self.max_retries:
17                    print(str(e))
18                    raise Exception(f"Failed to send notification after {self.max_retries} attempts.") from e
19                time.sleep(self.retry_delay_millis / 1000.0)

1class NotificationService:
2    def __init__(self, pool_size: int):
3        self.executor = ThreadPoolExecutor(max_workers=pool_size)
4
5    def send_notification(self, notification: Notification):
6        def send_task():
7            gateway = RetryableGatewayDecorator(
8                NotificationFactory.create_gateway(notification.get_type()),
9                3,
10                1000
11            )
12            try:
13                gateway.send(notification)
14            except Exception as e:
15                print(f"Exception while sending notification: {e}")
16
17        self.executor.submit(send_task)
18
19    def shutdown(self):
20        self.executor.shutdown()

1def main():
2    # 1. Setup the notification service
3    notification_service = NotificationService(10)
4
5    # 2. Define recipients
6    recipient1 = Recipient("user123", "[email protected]", None, "pushToken123")
7    recipient2 = Recipient("user456", None, "+15551234567", None)
8
9    # 3. Send various notifications using the Facade (NotificationService)
10
11    # Scenario 1: Send a welcome email
12    welcome_email = (Notification.Builder(recipient1, NotificationType.EMAIL)
13                     .subject("Welcome!")
14                     .message("Welcome to notification system")
15                     .build())
16    notification_service.send_notification(welcome_email)
17
18    # Scenario 2: Send a direct push notification
19    push_notification = (Notification.Builder(recipient1, NotificationType.PUSH)
20                        .subject("New Message")
21                        .message("You have a new message from Jane.")
22                        .build())
23    notification_service.send_notification(push_notification)
24
25    # Scenario 3: Send order confirmation SMS
26    order_sms = (Notification.Builder(recipient2, NotificationType.SMS)
27                .message("Your order for Digital Clock is confirmed")
28                .build())
29    notification_service.send_notification(order_sms)
30
31    # Wait for a moment to allow the queue processor to work
32    time.sleep(1)
33
34    # 4. Shutdown the system
35    print("\nShutting down the notification system...")
36    notification_service.shutdown()
37    print("System shut down successfully.")
38
39
40if __name__ == "__main__":
41    main()